package com.clusterswisdom.horn.api.tmall.dataSynService.imp;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.sql.Date;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

 


import org.apache.log4j.Logger;

import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.clusterswisdom.horn.api.db.DbUtil;
import com.clusterswisdom.horn.api.tmall.dataSynService.DbSynHandleTo;
import com.clusterswisdom.horn.api.tmall.dataSynService.common.DBSynDomainFactory;
import com.clusterswisdom.horn.api.tmall.dataSynService.common.DbSynConstrant;
import com.jolbox.bonecp.BoneCPDataSource;


 

/**
 * 目标数据库操作服务类：包括获取本地门店（或总店）标识、获取需要从哪些门店（或总店）接收数据的标识、 获取数据后入库处理并发挥操作信息。
 * 
 * @author li_qingsong
 * 
 */
 
public class TargetDbService implements DbSynHandleTo {
	private static final Logger logger = Logger
			.getLogger(TargetDbService.class);
 
	// jdbcTemplate
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
 

   public TargetDbService()
   {
	   BoneCPDataSource dataSource = DbUtil.getUtil().getDateSource();
	   dataSource.setDefaultAutoCommit(true);
	   
	   namedParameterJdbcTemplate=new NamedParameterJdbcTemplate(
			   dataSource);
   }
	@Override
	public String targetName() {

	 
		return "";

	}

	 
	public List<String> fetchSoureNames() throws Exception {
		 return null;
	}

	 

	/**
	 * 将从源数据库得到的数据更新到目标数据库,并反馈信息给源库
	 * 
	 * @param changedDate
	 *            接收的源库的数据
	 * @param sourceName
	 *            反馈信息的源标识，用于生成反馈队列
	 * @param targetName
	 *            反馈信息的目标标识 用于生成反馈队列
	 * 
	 * @return
	 * @throws Exception
	 */

	@Override
	public Map<String,Object> toDbDate(JSONObject receiveDate){

		Map<String, Object> result = new HashMap<String, Object>();
        //表名
        String tableName =receiveDate.getString(DbSynConstrant.TABLE_NAME);
		// 表主键名
		String priKeyName =receiveDate.getString(DbSynConstrant.PRIKEY_NAME);
		// // 产生变化的数据的操作类型
		String operFlag =receiveDate.getString(DbSynConstrant.OPER_FLAG);
		
		Map<String,Object> tableInfo = new HashMap<String,Object>();
		tableInfo.put(DbSynConstrant.TABLE_NAME, tableName);
		tableInfo.put(DbSynConstrant.PRIKEY_NAME, priKeyName);
		
		String resultInfo ="";
		String resultCode = DbSynConstrant.ACKCODE_SUCCESS;
	 
		
		List<SqlParameterSource> updateParames = new ArrayList<SqlParameterSource>();
		List<SqlParameterSource> insertParames = new ArrayList<SqlParameterSource>();
		
		String insertSql ="";
		String updateSql ="";
  
		String deleteFlag = receiveDate.getString(DbSynConstrant.DELETE_FLAG_KEY);
		//如果接收的数据标示为1 删除全表数据，则执行删除操作，并返回
		if(null !=deleteFlag && !"".equals(deleteFlag) && "1".equals(deleteFlag))
		{
			SqlParameterSource parames = new MapSqlParameterSource();
		    String sql = "delete  from "+tableName;	
		     
		    try
		    {
		    	namedParameterJdbcTemplate.update(sql, parames);
		    	resultCode = DbSynConstrant.ACKCODE_SUCCESS;
		    }catch(Exception e)
		    {
		    	logger.error(e.getMessage());
		     
				resultCode = DbSynConstrant.ACKCODE_FAILE;
				resultInfo = String.format("目标库删除整表数据失败，表名：%s，异常信息：%s", tableName,e.getMessage());
		    }
		    result.put(DbSynConstrant.ACK_RESULTCODE,
					String.valueOf(resultCode));
			result.put(DbSynConstrant.ACK_RESULTINFO, resultInfo);
			return result;
		}
		
		JSONArray dbDates = receiveDate.getJSONArray("dbDates");
		for(Iterator it = dbDates.iterator();it.hasNext();)
		{
			// 将该数据的map的key转换为大写形式，
			Map<String, Object> upperKeyDates = new HashMap<String, Object>();
            
			Map<String,Object> datesTemp = (Map<String,Object> )it.next();
			coverdMapToKeyUpperCase(datesTemp, upperKeyDates);
			putOneDataInf(upperKeyDates,tableInfo);
			// 将该表的此条记录的map形式数据的key全部转换为大写，便于根据key值转换为该表对应的domai
			Object domainobject = null;
			
			try
			{
				domainobject = getDomainObjectByTableName(
						tableName, upperKeyDates);
			}catch(Exception e)
			{
				resultCode = DbSynConstrant.ACKCODE_FAILE;
				resultInfo = e.getMessage();
				
				result.put(DbSynConstrant.ACK_RESULTCODE,
						String.valueOf(resultCode));
				result.put(DbSynConstrant.ACK_RESULTINFO, resultInfo);
				return result;
			}
			
			try
			{
				insertSql = insertObjectToDb(tableName,upperKeyDates,domainobject);
				updateSql = updateObjectToDb(tableInfo,upperKeyDates,domainobject);
			}catch(Exception e)
			{
				resultCode = DbSynConstrant.ACKCODE_FAILE;
				resultInfo = e.getMessage();
				
				result.put(DbSynConstrant.ACK_RESULTCODE,
						String.valueOf(resultCode));
				result.put(DbSynConstrant.ACK_RESULTINFO, resultInfo);
				return result;
			}
			
			SqlParameterSource  namedParameters= new BeanPropertySqlParameterSource(
						domainobject);
				//如果全量发送数据，则全部新增。（默认之前已经做过全部删除操作）
			if(null !=operFlag && !"".equals(operFlag)&&DbSynConstrant.FULL_DATA_SEND.equals(operFlag))
			{ 
				   //如果是全量发送数据则全新增
				 insertParames.add(namedParameters);
					 
			}
			//如果增量，则判定数据是否存在
			if(null !=operFlag && !"".equals(operFlag)&&DbSynConstrant.MODIFY_DATA_SEND.equals(operFlag))
			{
				try
				{
					// 判断根据该条记录ID，判断在目标库中是否存在
					if (ObjectExistInDb(tableInfo)) {
							// 如果该条记录存在，则更加主键ID进行全部字段更新
						updateParames.add(namedParameters);
							//logger.debug(String.format("目标库更新一条记录成功"));
					} else {
							// 如果该记录在目标库不存在，则新增进目标库中
						insertParames.add(namedParameters);		 
							//logger.debug(String.format("目标库新增一条记录成功 "));
					}	
				}catch(Exception e)
				{
					resultCode = DbSynConstrant.ACKCODE_FAILE;
					resultInfo = e.getMessage();
					
					result.put(DbSynConstrant.ACK_RESULTCODE,
							String.valueOf(resultCode));
					result.put(DbSynConstrant.ACK_RESULTINFO, resultInfo);
					return result;
				}
				
			}			  		 
		}
			
		
		

		if(updateParames.size() > 0)
		{
			try
			{
				namedParameterJdbcTemplate.batchUpdate(updateSql,(SqlParameterSource[])updateParames.toArray(new SqlParameterSource[updateParames.size()]));	
			}catch(Exception e)
			{
				logger.error(e.getMessage());
				resultCode = DbSynConstrant.ACKCODE_FAILE;
				resultInfo = String.format("目标库更新数据失败，表名：%s，异常信息：%s", tableName,e.getMessage());
			}
			
			 
		}
		
		if(insertParames.size() > 0)
		{
			try
			{
				namedParameterJdbcTemplate.batchUpdate(insertSql,(SqlParameterSource[])insertParames.toArray(new SqlParameterSource[insertParames.size()]));
			}catch(Exception e)
			{
				logger.error(e.getMessage());
				
				resultCode = DbSynConstrant.ACKCODE_FAILE;
				resultInfo = String.format("目标库新增数据失败，表名：%s，异常信息：%s", tableName,e.getMessage());
			}	
		}
		
		 
		result.put(DbSynConstrant.ACK_RESULTCODE,
				String.valueOf(resultCode));
		result.put(DbSynConstrant.ACK_RESULTINFO, resultInfo);
		 
		namedParameterJdbcTemplate = null;
		return result;
	 
		
		  

	}

 

	public void putOneDataInf(Map<String,Object> dates,Map<String,Object> tableInfo)
	{
		String priKeyNames = (String)tableInfo.get(DbSynConstrant.PRIKEY_NAME);
		
		// 表的主键 如果复合主键 用 , 分开
		String[] priKeyName = priKeyNames.split(DbSynConstrant.KEY_SPLIT);
		StringBuffer prikeyValues = new StringBuffer();
		for (int j = 0; j < priKeyName.length; j++) {
			String priKeyNameString = priKeyName[j];
			String prikeyValue =(String) dates.get(priKeyNameString.toUpperCase());
			
			if(j==0)
			{
				prikeyValues.append(prikeyValue);
			}else
			{
				prikeyValues.append(","+prikeyValue);
			}
		}
		tableInfo.put(DbSynConstrant.PRIKEY_VALUE, prikeyValues.toString()); 
	}
	/**
	 * 根据表名和数据获取相应的domain对象
	 * 
	 * @param domainObject
	 * @param tableName
	 * @return
	 */
	private Object getDomainObjectByTableName(String tableName,
			Map<String, Object> dates) throws Exception {
		String domainclass = "";
		// 更加表名获取该表对应的domain类名
		domainclass = DBSynDomainFactory.getClassByTableName(tableName);
		if (null ==domainclass && "".equals(tableName.trim())) {
			logger.error(String.format("表名为：" + tableName
					+ "对应的domain类为空！请检查配置文件是否正确"));
			throw new Exception("表名为：" + tableName + "对应的domain类为空！请检查配置文件是否正确");

			// continue;
		}
		// 更加表名获取该表对应的domain对象
		Object domainObject = DBSynDomainFactory
				.getDomainByTableName(tableName);

		if (null == domainObject) {
			logger.error(String.format("表名为：" + tableName
					+ "对应的domain类为空或不存在！请检查配置文件是否正确"));
			throw new Exception("表名为：" + tableName
					+ "对应的domain类为空或不存在！请检查配置文件是否正确");
		}
		try {
			domainObject = toBean(domainObject.getClass(), dates);
		} catch (Exception e) {
			logger.error(String.format("表名为：" + tableName
					+ "对应的数据转换为domain类出错！"));
			throw new Exception(String.format("表名为：" + tableName
					+ "对应的数据转换为domain类出错！异常信息：" + e.getMessage()));
		}

		return domainObject;
	}

	private void coverdMapToKeyUpperCase(Map<String, Object> sourceMap,
			Map<String, Object> targetMap) {
		for (String key : sourceMap.keySet()) {
			// 如果源库中数据状态是业务系统”新增 1或修改 2“，则同步后状态为“同步状态 0”
			// 如果源库中数据状态是业务系统“删除3”，则同步后状态为“同步删除4”
			if ("DataFlag".equalsIgnoreCase(key)) {
				 

			} else {
				targetMap.put(key.toUpperCase(), sourceMap.get(key));
			}
		}
	}

	/**
	 * 将map转换为bean
	 * 
	 * @param type
	 * @param map
	 * @return
	 * @throws IntrospectionException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 * @throws InvocationTargetException
	 */
	private static final Object toBean(Class<?> type,
			Map<String, ? extends Object> map) throws IntrospectionException,
			IllegalAccessException, InstantiationException,
			InvocationTargetException, ParseException, Exception {

		BeanInfo beanInfo = Introspector.getBeanInfo(type);
		Object obj = type.newInstance();
		PropertyDescriptor[] propertyDescriptors = beanInfo
				.getPropertyDescriptors();
		// 根据bean属性，遍历map的内容，作相应的装换
		for (int i = 0; i < propertyDescriptors.length; i++) {
			PropertyDescriptor descriptor = propertyDescriptors[i];
			String propertyName = descriptor.getName();
			if (map.containsKey(propertyName.toUpperCase())) {
				Object value = map.get(propertyName.toUpperCase());

				Object[] args = new Object[1];
				args[0] = value;
				// 获取属性类型
				Class propertyType = descriptor.getPropertyType();
				try {
					// 日期格式 特殊处理
					if ("java.sql.Timestamp".equals(propertyType.getName())
							&& null != value) {

						SimpleDateFormat fmt = new SimpleDateFormat(
								"yyyy-MM-dd HH:mm:ss:SSSSSS");
						Timestamp timestamp = null;
						 
						if ("null".equals(value)) {
							 
							timestamp = null;
						} else {
							 
							timestamp = new Timestamp((Long)value);
						}
						descriptor.getWriteMethod().invoke(obj, timestamp);

					} else if ("java.sql.Date".equals(propertyType.getName())
							&& null != value) {
						SimpleDateFormat fmt = new SimpleDateFormat(
								"yyyy-MM-dd");
						java.util.Date valueDate = null;
						Date sqlDate = null;
						if ("null".equals(value)) {
							valueDate = null;
						} else {
							//valueDate = fmt.parse((String) value);
							sqlDate = new Date((Long)value);
						}
						descriptor.getWriteMethod().invoke(obj, sqlDate);

					} else if ("java.sql.Time".equals(propertyType.getName())
							&& null != value) {
						java.sql.Time sqltime = null;
						java.util.Date dateValue = null;
						if ("null".equals(value)) {
							sqltime = null;
						} else {
							String dateString =String.valueOf(value);
							SimpleDateFormat fmt = null;
							//mysql 中time存储格式“HH:mm:ss” oracle 中“yyyy-MM-dd HH:mm:ss:SSSSSS”
							//所以针对time类型需要特殊处理
							if(dateString.contains("-"))
							{
								fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSSSSS");
							}else
							{
								fmt = new SimpleDateFormat("HH:mm:ss");
							}
							dateValue = fmt.parse(dateString);
							sqltime = new java.sql.Time((Long)value);
						}
						descriptor.getWriteMethod().invoke(obj, sqltime);
					} // 如果数据库中的小数点后为0，则oracle查询结果后会自动删除0，则map中object则为int，需要特殊处理
					else if ("java.lang.Double".equals(propertyType.getName())
							&& null != value) {
						Double valueDate = Double
								.valueOf(String.valueOf(value));
						descriptor.getWriteMethod().invoke(obj, valueDate);
					}else if ("java.lang.String".equals(propertyType.getName())
							&& null != value) {
						String valueDate = String.valueOf(value);
						descriptor.getWriteMethod().invoke(obj, valueDate);
					} else {
						 
						descriptor.getWriteMethod().invoke(obj, args);
					}

				} catch (Exception e) {
					throw new Exception(
							String.format(
									"根据接收数据map转换为domain对象时出错,请检查数据库字段类型与domain类中字段类型是否匹配，domain属性：%s，类型：%s，map值类型：%s，值：%s，异常信息：%s",
									propertyName, propertyType.getName(), value
											.getClass().getName(), value
											.toString(), e.getMessage()));
				}

			}

		}
		return obj;
	}

	/**
	 * 根据key值获取对应domain中的对应的属性
	 * 
	 * @param type
	 * @param mapKey
	 * @return
	 * @throws Exception
	 */
	private String creatValue(Class<?> type, String mapKey) throws Exception {

		BeanInfo beanInfo = Introspector.getBeanInfo(type);

		PropertyDescriptor[] propertyDescriptors = beanInfo
				.getPropertyDescriptors();

		String propertyName = "";
		String returnValue = "";
		PropertyDescriptor descriptor = null;
		for (int i = 0; i < propertyDescriptors.length; i++) {
			descriptor = propertyDescriptors[i];
			propertyName = descriptor.getName();

			if (propertyName.equalsIgnoreCase(mapKey)) {
				returnValue = propertyName;
			}
		}

		if (null ==returnValue || "".equals(returnValue)) {
			throw new Exception(String.format(
					"根据表字段获取domain类属性失败，请检查domain对象属性是否和表字段对应：domain类%s,表字段%s",
					type.getName(), mapKey));
		}

		return returnValue;

	}

	/**
	 * 根据表名和数据记录信息，将该信息新增到目标库中
	 * 
	 * @param tableName
	 * @param dates
	 * @param domainobject
	 * @return
	 * @throws Exception
	 */
	private String insertObjectToDb(String tableName, Map<String, Object> dates,
			Object domainobject) throws Exception {

		StringBuffer sql = new StringBuffer("insert into " + tableName + " ( ");
		Set keys = dates.keySet();
		int i = 0;
		StringBuffer sqlColums = new StringBuffer();
		StringBuffer sqlValues = new StringBuffer();
		// 遍历记录map key为数据表的列名，value为该列值
		for (Object key : dates.keySet()) {
			if("ROWNUMBER".equals((String)key))
			{
				i++;
				continue;
			}
			if (i < keys.size() - 1) {
				sqlColums.append((String) key + ",");
				sqlValues.append(":"
						+ creatValue(domainobject.getClass(), (String) key)
						+ " ,");
			} else if (i == keys.size() - 1) {
				sqlColums.append((String) key);
				sqlValues.append(":"
						+ creatValue(domainobject.getClass(), (String) key));
			}

			i++;
		}
		sql.append(sqlColums);
		sql.append(" ) values(  ");
		sql.append(sqlValues);
		sql.append(")");
		//SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(
		//		domainobject);
		//int result = namedParameterJdbcTemplate.update(sql.toString(),
		//		namedParameters);
		 return sql.toString();
		 
	}

	/**
	 * 判断根据该条记录信息，判断在目标库中是否存在
	 * 
	 * @param mapinf
	 * @return true 存在 false 不存在
	 * @throws Exception
	 */
	private boolean ObjectExistInDb(Map<String, Object> mapinf)
			throws Exception {
		// 表名
		String tableName = (String) mapinf.get(DbSynConstrant.TABLE_NAME);
		// 表主键值
		String priKeyValues = (String) mapinf.get(DbSynConstrant.PRIKEY_VALUE);
		// 表主键名
		String priKeyNames = (String) mapinf.get(DbSynConstrant.PRIKEY_NAME);

		// 根据表名、主键名、主键值，查询该记录是否存在
		StringBuffer sql = new StringBuffer("select count(*) from " + tableName
				+ " where  ");
		// 表的主键 如果复合主键 用 , 分开
		String[] priKeyName = priKeyNames.split(DbSynConstrant.KEY_SPLIT);
		String[] priKeyValue = priKeyValues.split(DbSynConstrant.KEY_SPLIT);
		Map<String, String> paramMap = new HashMap<String, String>();
		for (int i = 0; i < priKeyName.length; i++) {
			if (i == 0) {
				sql.append(priKeyName[i] + " = :" + priKeyName[i]);
				paramMap.put(priKeyName[i], priKeyValue[i]);
			} else {
				sql.append(" AND " + priKeyName[i] + " = :" + priKeyName[i]);
				paramMap.put(priKeyName[i], priKeyValue[i]);
			}
		}

		int result = namedParameterJdbcTemplate.queryForInt(sql.toString(),
				paramMap);
		if (result > 0) {
			return true;
		}
		return false;
	}

	/**
	 * 根据表名和数据记录信息，将该信息更新到目标库中
	 * 
	 * @param mapinf
	 * @param dates
	 * @param domainobject
	 * @return
	 * @throws Exception
	 */
	private String updateObjectToDb(Map<String, Object> mapinf,
			Map<String, Object> dates, Object domainobject) throws Exception {

		// 表名
		String tableName = (String) mapinf.get(DbSynConstrant.TABLE_NAME);
		// 表主键值
		String priKeyValues = (String) mapinf.get(DbSynConstrant.PRIKEY_VALUE);
		// 表主键名
		String priKeyNames = (String) mapinf.get(DbSynConstrant.PRIKEY_NAME);
		// 数据更新sql语句
		StringBuffer sql = new StringBuffer("update " + tableName + " set  ");
		Set keys = dates.keySet();
		int i = 0;
		// 遍历记录map key为数据表的列名，value为该列值
		for (Object key : keys) {
			if("ROWNUMBER".equals((String)key))
			{
				i++;
				continue;
			}
					 		 
			if (i < keys.size() - 1) {
				sql.append((String) key + "= :"
						+ creatValue(domainobject.getClass(), (String) key)
						+ ",");

			} else if (i == keys.size() - 1) {
				sql.append((String) key + "= :"
						+ creatValue(domainobject.getClass(), (String) key));
			}

			i++;
		}
		sql.append("  where ");

		// 表的主键 如果复合主键 用 ,分开
		String[] priKeyName = priKeyNames.split(DbSynConstrant.KEY_SPLIT);
		//String[] priKeyValue = priKeyValues.split(DbSynConstrant.KEY_SPLIT);

		for (int j = 0; j < priKeyName.length; j++) {
			if (j == 0) {
				sql.append(priKeyName[j] + " = :"+creatValue(domainobject.getClass(), priKeyName[j]));

			} else {
				sql.append(" AND " + priKeyName[j] + " = :"+creatValue(domainobject.getClass(), priKeyName[j]));

			}
		}
		// 更新语句使用的参数
		//SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(
		//		domainobject);
		//paramers.add(namedParameters);
		return sql.toString();
		//int result = namedParameterJdbcTemplate.update(sql.toString(),
		//		namedParameters);
//		if(1 == result)
//		{
//			return DbSynConstrant.ACKCODE_SUCCESS;
//		}else
//		{
//			return DbSynConstrant.ACKCODE_FAILE;
//		}
	 
	}

	/**
	 * 根据表名和数据记录信息，将该信息更新到目标库中
	 * 
	 * @param mapinf
	 * @param dates
	 * @param domainobject
	 * @return
	 * @throws Exception
	 */
	private String deleteObjectToDb(Map<String, Object> mapinf) throws Exception {
		String  deployFlag ="";
		if(null == deployFlag || "".equals(deployFlag))
		{
			deployFlag ="2";//默认为 2门店
		}
		 
		// 表名
		String tableName = (String) mapinf.get(DbSynConstrant.TABLE_NAME);
		// 表主键值
		String priKeyValues = (String) mapinf.get(DbSynConstrant.PRIKEY_VALUE);
		// 表主键名
		String priKeyNames = (String) mapinf.get(DbSynConstrant.PRIKEY_NAME);
		// 数据更新sql语句
		StringBuffer sql = new StringBuffer("delete from " + tableName);

		sql.append("  where ");

		// 表的主键 如果复合主键 用 ,分开
		String[] priKeyName = priKeyNames.split(DbSynConstrant.KEY_SPLIT);
		String[] priKeyValue = priKeyValues.split(DbSynConstrant.KEY_SPLIT);

		for (int j = 0; j < priKeyName.length; j++) {
			String priKeyNameString = priKeyName[j];
			String priKeyValueString =priKeyValue[j];
			//处理删除操作中的特殊情况：添加了一个时间戳，用于
			//防止触发器的二次触发而删除新增的同一个主键的值
			if("CreateTime".toUpperCase().equals(priKeyNameString.toUpperCase()))
			{
				//如果部署在门店则处理日期类型（mysql）
				if(DbSynConstrant.DEPLOY_SUB.equals(deployFlag))
				//mysql数据库接收的时间格式为在oracle库中的触发器已经格式化为YYYY-MM-DD hh24:mi:ss的，
				//所以可以同处理其他主键的方式一样处理
				{
					if (j == 0) {
						sql.append(priKeyNameString + " = '" + priKeyValueString + "'");

					} else {
						sql.append(" AND " + priKeyNameString + " = '" + priKeyValueString
								+ "'");
					}
				}else if(DbSynConstrant.DEPLOY_HQ.equals(deployFlag))
				//如果部署在总部，则处理日期类型（oracle）
			    // oracle 需要将日期类型转换为一定格式的日期，再操作
				{
					priKeyNameString ="TO_CHAR("+priKeyName[j]+",'YYYY-MM-DD hh24:mi:ss')";
					//priKeyValueString ="TO_CHAR("+priKeyValue[j]+",'YYYY-MM-DD hh24:mi:ss')";
					if (j == 0) {
						sql.append(priKeyNameString + " = " + priKeyValueString );

					} else {
						sql.append(" AND " + priKeyNameString + " = '" + priKeyValueString+ "'");
					}
				}
			}else
			{
				if (j == 0) {
					sql.append(priKeyNameString + " = '" + priKeyValueString + "'");

				} else {
					sql.append(" AND " + priKeyNameString + " = '" + priKeyValueString
							+ "'");
				}
			}
			
			
		}
		Map<String, Object> param = new HashMap<String, Object>();
		int result = namedParameterJdbcTemplate.update(sql.toString(), param);
		return DbSynConstrant.ACKCODE_SUCCESS;
	}

	 

}
